//! # 配置兼容性模块
//!
//! 本模块提供了向后兼容的配置类型别名，确保现有代码在重构后仍能正常工作。
//! 所有旧的配置类型都重定向到统一配置模块中的对应类型。
//!
//! ## 使用说明
//!
//! 现有代码可以继续使用原有的配置类型名称，无需修改：
//!
//! ```rust
//! use rustcloud_core::RegistryConfig;  // 自动使用统一配置
//! 
//! let config = RegistryConfig::default();
//! ```
//!
//! ## 迁移建议
//!
//! 建议逐步迁移到统一配置系统：
//!
//! ```rust
//! // 推荐方式：使用统一配置
//! use rustcloud_core::UnifiedConfig;
//! 
//! let config = UnifiedConfig::default();
//! let registry_config = &config.registry;
//! ```

use crate::config_unified::*;

// =============================================================================
// 向后兼容的配置类型别名
// =============================================================================

/// 向后兼容：注册中心配置
/// 
/// 现已重定向到统一配置模块中的 `RegistryConfig`
pub type RegistryConfig = crate::config_unified::RegistryConfig;

/// 向后兼容：负载均衡配置
/// 
/// 现已重定向到统一配置模块中的 `LoadBalancerConfig`
pub type LoadBalancerConfig = crate::config_unified::LoadBalancerConfig;

/// 向后兼容：熔断器配置
/// 
/// 现已重定向到统一配置模块中的 `CircuitBreakerConfig`
pub type CircuitBreakerConfig = crate::config_unified::CircuitBreakerConfig;

/// 向后兼容：传输层配置
/// 
/// 现已重定向到统一配置模块中的 `TransportConfig`
pub type TransportConfig = crate::config_unified::TransportConfig;

/// 向后兼容：网络配置
/// 
/// 现已重定向到统一配置模块中的 `NetworkConfig`
pub type NetworkConfig = crate::config_unified::NetworkConfig;

/// 向后兼容：服务配置
/// 
/// 现已重定向到统一配置模块中的 `ServiceConfig`
pub type ServiceConfig = crate::config_unified::ServiceConfig;

/// 向后兼容：指标配置
/// 
/// 现已重定向到统一配置模块中的 `MetricsConfig`
pub type MetricsConfig = crate::config_unified::MetricsConfig;

/// 向后兼容：链路追踪配置
/// 
/// 现已重定向到统一配置模块中的 `TracingConfig`
pub type TracingConfig = crate::config_unified::TracingConfig;

/// 向后兼容：日志配置
/// 
/// 现已重定向到统一配置模块中的 `LoggingConfig`
pub type LoggingConfig = crate::config_unified::LoggingConfig;

/// 向后兼容：安全配置
/// 
/// 现已重定向到统一配置模块中的 `SecurityConfig`
pub type SecurityConfig = crate::config_unified::SecurityConfig;

/// 向后兼容：网关配置
/// 
/// 现已重定向到统一配置模块中的 `GatewayConfig`
pub type GatewayConfig = crate::config_unified::GatewayConfig;

/// 向后兼容：健康检查配置
/// 
/// 现已重定向到统一配置模块中的 `HealthCheckConfig`
pub type HealthCheckConfig = crate::config_unified::HealthCheckConfig;

/// 向后兼容：TLS配置
/// 
/// 现已重定向到统一配置模块中的 `TlsConfig`
pub type TlsConfig = crate::config_unified::TlsConfig;

/// 向后兼容：连接池配置
/// 
/// 现已重定向到统一配置模块中的 `ConnectionPoolConfig`
pub type ConnectionPoolConfig = crate::config_unified::ConnectionPoolConfig;

/// 向后兼容：认证配置
/// 
/// 现已重定向到统一配置模块中的 `AuthConfig`
pub type AuthConfig = crate::config_unified::AuthConfig;

/// 向后兼容：负载均衡策略
/// 
/// 现已重定向到统一配置模块中的 `LoadBalancerStrategy`
pub type LoadBalancerStrategy = crate::config_unified::LoadBalancerStrategy;

/// 向后兼容：一致性哈希配置
/// 
/// 现已重定向到统一配置模块中的 `ConsistentHashConfig`
pub type ConsistentHashConfig = crate::config_unified::ConsistentHashConfig;

/// 向后兼容：粘性会话配置
/// 
/// 现已重定向到统一配置模块中的 `StickySessionConfig`
pub type StickySessionConfig = crate::config_unified::StickySessionConfig;

/// 向后兼容：路由配置
/// 
/// 现已重定向到统一配置模块中的 `RouteConfig`
pub type RouteConfig = crate::config_unified::RouteConfig;

/// 向后兼容：过滤器配置
/// 
/// 现已重定向到统一配置模块中的 `FilterConfig`
pub type FilterConfig = crate::config_unified::FilterConfig;

/// 向后兼容：限流配置
/// 
/// 现已重定向到统一配置模块中的 `RateLimitConfig`
pub type RateLimitConfig = crate::config_unified::RateLimitConfig;

/// 向后兼容：限流规则
/// 
/// 现已重定向到统一配置模块中的 `RateLimitRule`
pub type RateLimitRule = crate::config_unified::RateLimitRule;

// =============================================================================
// 配置工厂函数（向后兼容）
// =============================================================================

/// 创建默认的注册中心配置
/// 
/// 这是一个便利函数，用于创建适用于开发环境的默认注册中心配置。
pub fn default_registry_config() -> RegistryConfig {
    RegistryConfig::default()
}

/// 创建默认的负载均衡配置
/// 
/// 这是一个便利函数，用于创建适用于大多数场景的负载均衡配置。
pub fn default_load_balancer_config() -> LoadBalancerConfig {
    LoadBalancerConfig::default()
}

/// 创建默认的熔断器配置
/// 
/// 这是一个便利函数，用于创建适用于大多数场景的熔断器配置。
pub fn default_circuit_breaker_config() -> CircuitBreakerConfig {
    CircuitBreakerConfig::default()
}

/// 创建生产环境推荐的配置
/// 
/// 这个函数返回一个针对生产环境优化的统一配置，包含了推荐的安全设置、
/// 性能参数和监控配置。
pub fn production_config(service_name: &str) -> UnifiedConfig {
    let mut config = UnifiedConfig::default();
    
    // 设置服务配置
    config.service.name = service_name.to_string();
    config.service.environment = "prod".to_string();
    
    // 设置生产环境网络配置
    config.network.host = "0.0.0.0".to_string();
    
    // 启用安全功能
    config.security.enabled = true;
    
    // 启用指标收集
    config.metrics.enabled = true;
    config.metrics.collection_interval_seconds = 15;
    
    // 启用链路追踪（低采样率）
    config.tracing.enabled = true;
    config.tracing.sampling_rate = 0.01; // 1% 采样率
    
    // 设置生产环境日志配置
    config.logging.level = "warn".to_string();
    config.logging.format = "json".to_string();
    
    // 设置生产环境熔断器配置
    config.circuit_breaker.enabled = true;
    config.circuit_breaker.failure_rate_threshold = 0.5;
    config.circuit_breaker.min_request_threshold = 20;
    
    config
}

/// 创建开发环境推荐的配置
/// 
/// 这个函数返回一个针对开发环境优化的统一配置，包含了便于调试的设置。
pub fn development_config(service_name: &str) -> UnifiedConfig {
    let mut config = UnifiedConfig::default();
    
    // 设置服务配置
    config.service.name = service_name.to_string();
    config.service.environment = "dev".to_string();
    
    // 使用内存注册中心
    config.registry.registry_type = "memory".to_string();
    
    // 禁用安全功能（开发环境）
    config.security.enabled = false;
    
    // 启用详细指标收集
    config.metrics.enabled = true;
    config.metrics.collection_interval_seconds = 5;
    
    // 启用链路追踪（高采样率）
    config.tracing.enabled = true;
    config.tracing.sampling_rate = 1.0; // 100% 采样率
    
    // 设置开发环境日志配置
    config.logging.level = "debug".to_string();
    config.logging.format = "text".to_string();
    config.logging.output = "console".to_string();
    
    // 设置宽松的熔断器配置
    config.circuit_breaker.enabled = false; // 开发环境禁用熔断器
    
    config
}

// =============================================================================
// 配置构建器（向后兼容）
// =============================================================================

/// 配置构建器
/// 
/// 提供链式调用的方式来构建配置，支持向后兼容的 API。
pub struct ConfigBuilder {
    config: UnifiedConfig,
}

impl ConfigBuilder {
    /// 创建新的配置构建器
    pub fn new(service_name: &str) -> Self {
        let mut config = UnifiedConfig::default();
        config.service.name = service_name.to_string();
        
        Self { config }
    }
    
    /// 设置服务端口
    pub fn with_port(mut self, port: u16) -> Self {
        self.config.network.port = port;
        self
    }
    
    /// 设置注册中心类型
    pub fn with_registry_type(mut self, registry_type: &str) -> Self {
        self.config.registry.registry_type = registry_type.to_string();
        self
    }
    
    /// 设置注册中心地址
    pub fn with_registry_endpoints(mut self, endpoints: Vec<String>) -> Self {
        self.config.registry.endpoints = endpoints;
        self
    }
    
    /// 设置负载均衡策略
    pub fn with_load_balancer_strategy(mut self, strategy: LoadBalancerStrategy) -> Self {
        self.config.load_balancer.strategy = strategy;
        self
    }
    
    /// 启用熔断器
    pub fn enable_circuit_breaker(mut self) -> Self {
        self.config.circuit_breaker.enabled = true;
        self
    }
    
    /// 启用指标收集
    pub fn enable_metrics(mut self) -> Self {
        self.config.metrics.enabled = true;
        self
    }
    
    /// 启用链路追踪
    pub fn enable_tracing(mut self, sampling_rate: f64) -> Self {
        self.config.tracing.enabled = true;
        self.config.tracing.sampling_rate = sampling_rate;
        self
    }
    
    /// 设置日志级别
    pub fn with_log_level(mut self, level: &str) -> Self {
        self.config.logging.level = level.to_string();
        self
    }
    
    /// 构建配置
    pub fn build(self) -> UnifiedConfig {
        self.config
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_backward_compatibility() {
        // 测试向后兼容的类型别名
        let registry_config = RegistryConfig::default();
        assert_eq!(registry_config.registry_type, "memory");
        
        let lb_config = LoadBalancerConfig::default();
        assert_eq!(lb_config.strategy, LoadBalancerStrategy::RoundRobin);
        
        let cb_config = CircuitBreakerConfig::default();
        assert!(cb_config.enabled);
    }
    
    #[test]
    fn test_production_config() {
        let config = production_config("test-service");
        assert_eq!(config.service.name, "test-service");
        assert_eq!(config.service.environment, "prod");
        assert!(config.security.enabled);
        assert!(config.metrics.enabled);
        assert_eq!(config.logging.level, "warn");
    }
    
    #[test]
    fn test_development_config() {
        let config = development_config("test-service");
        assert_eq!(config.service.name, "test-service");
        assert_eq!(config.service.environment, "dev");
        assert!(!config.security.enabled);
        assert!(config.metrics.enabled);
        assert_eq!(config.logging.level, "debug");
    }
    
    #[test]
    fn test_config_builder() {
        let config = ConfigBuilder::new("test-service")
            .with_port(8080)
            .with_registry_type("nacos")
            .with_registry_endpoints(vec!["127.0.0.1:8848".to_string()])
            .with_load_balancer_strategy(LoadBalancerStrategy::Random)
            .enable_circuit_breaker()
            .enable_metrics()
            .enable_tracing(0.1)
            .with_log_level("info")
            .build();
            
        assert_eq!(config.service.name, "test-service");
        assert_eq!(config.network.port, 8080);
        assert_eq!(config.registry.registry_type, "nacos");
        assert_eq!(config.registry.endpoints, vec!["127.0.0.1:8848"]);
        assert_eq!(config.load_balancer.strategy, LoadBalancerStrategy::Random);
        assert!(config.circuit_breaker.enabled);
        assert!(config.metrics.enabled);
        assert!(config.tracing.enabled);
        assert_eq!(config.tracing.sampling_rate, 0.1);
        assert_eq!(config.logging.level, "info");
    }
}